import {Utility} from './utility'
import html2pdf from 'html2pdf.js'
import html2canvas from 'html2canvas'
import printJS from 'print-js'

export const forEach = (arr, fn) => {
    if (!arr.length || !fn) return
    let i = -1
    let len = arr.length
    while (++i < len) {
        let item = arr[i]
        fn(item, i, arr)
    }
}

/** 保留两位小数 */
export function formatDecimal(num) {
    // 转换为数字类型并校验有效性
    const number = Number(num)
    if (isNaN(number)) {
        return num // 非数字返回原值
    }

    // 四舍五入保留两位小数
    const roundedNum = Math.round(number * 100) / 100

    // 判断是否为整数，是则返回整数形式，否则保留最多两位小数
    return roundedNum % 1 === 0 ? roundedNum.toString() : roundedNum.toFixed(2).replace(/\.?0*$/, '')
}

/**
 * @param {Array} arr1
 * @param {Array} arr2
 * @description 得到两个数组的交集, 两个数组的元素为数值或字符串
 */
export const getIntersection = (arr1, arr2) => {
    let len = Math.min(arr1.length, arr2.length)
    let i = -1
    let res = []
    while (++i < len) {
        const item = arr2[i]
        if (arr1.indexOf(item) > -1) res.push(item)
    }
    return res
}

/**
 * @param {Array} arr1
 * @param {Array} arr2
 * @description 得到两个数组的并集, 两个数组的元素为数值或字符串
 */
export const getUnion = (arr1, arr2) => {
    return Array.from(new Set([...arr1, ...arr2]))
}

/**
 * @param {Array} target 目标数组
 * @param {Array} arr 需要查询的数组
 * @description 判断要查询的数组是否至少有一个元素包含在目标数组中
 */
export const hasOneOf = (targetarr, arr) => {
    return targetarr.some((_) => arr.indexOf(_) > -1)
}

/**
 * @param {String|Number} value 要验证的字符串或数值
 * @param {*} validList 用来验证的列表
 */
export function oneOf(value, validList) {
    for (let i = 0; i < validList.length; i++) {
        if (value === validList[i]) {
            return true
        }
    }
    return false
}

/**
 * @param {Number} timeStamp 判断时间戳格式是否是毫秒
 * @returns {Boolean}
 */
const isMillisecond = (timeStamp) => {
    const timeStr = String(timeStamp)
    return timeStr.length > 10
}

/**
 * @param {Number} timeStamp 传入的时间戳
 * @param {Number} currentTime 当前时间时间戳
 * @returns {Boolean} 传入的时间戳是否早于当前时间戳
 */
const isEarly = (timeStamp, currentTime) => {
    return timeStamp < currentTime
}

/**
 * @param {Number} num 数值
 * @returns {String} 处理后的字符串
 * @description 如果传入的数值小于10，即位数只有1位，则在前面补充0
 */
const getHandledValue = (num) => {
    return num < 10 ? '0' + num : num
}

/**
 * @param {Number} timeStamp 传入的时间戳
 * @param {Number} startType 要返回的时间字符串的格式类型，传入'year'则返回年开头的完整时间
 */
const getDate = (timeStamp, startType) => {
    const d = new Date(timeStamp * 1000)
    const year = d.getFullYear()
    const month = getHandledValue(d.getMonth() + 1)
    const date = getHandledValue(d.getDate())
    const hours = getHandledValue(d.getHours())
    const minutes = getHandledValue(d.getMinutes())
    const second = getHandledValue(d.getSeconds())
    let resStr = ''
    if (startType === 'year') resStr = year + '-' + month + '-' + date + ' ' + hours + ':' + minutes + ':' + second
    else resStr = month + '-' + date + ' ' + hours + ':' + minutes
    return resStr
}

/**
 * @param {String|Number} timeStamp 时间戳
 * @returns {String} 相对时间字符串
 */
export const getRelativeTime = (timeStamp) => {
    // 判断当前传入的时间戳是秒格式还是毫秒
    const IS_MILLISECOND = isMillisecond(timeStamp)
    // 如果是毫秒格式则转为秒格式
    if (IS_MILLISECOND) Math.floor((timeStamp /= 1000))
    // 传入的时间戳可以是数值或字符串类型，这里统一转为数值类型
    timeStamp = Number(timeStamp)
    // 获取当前时间时间戳
    const currentTime = Math.floor(Date.parse(new Date()) / 1000)
    // 判断传入时间戳是否早于当前时间戳
    const IS_EARLY = isEarly(timeStamp, currentTime)
    // 获取两个时间戳差值
    let diff = currentTime - timeStamp
    // 如果IS_EARLY为false则差值取反
    if (!IS_EARLY) diff = -diff
    let resStr = ''
    const dirStr = IS_EARLY ? '前' : '后'
    // 少于等于59秒
    if (diff <= 59) resStr = diff + '秒' + dirStr
    // 多于59秒，少于等于59分钟59秒
    else if (diff > 59 && diff <= 3599) resStr = Math.floor(diff / 60) + '分钟' + dirStr
    // 多于59分钟59秒，少于等于23小时59分钟59秒
    else if (diff > 3599 && diff <= 86399) resStr = Math.floor(diff / 3600) + '小时' + dirStr
    // 多于23小时59分钟59秒，少于等于29天59分钟59秒
    else if (diff > 86399 && diff <= 2623859) resStr = Math.floor(diff / 86400) + '天' + dirStr
    // 多于29天59分钟59秒，少于364天23小时59分钟59秒，且传入的时间戳早于当前
    else if (diff > 2623859 && diff <= 31567859 && IS_EARLY) resStr = getDate(timeStamp)
    else resStr = getDate(timeStamp, 'year')
    return resStr
}

/**
 * @returns {String} 当前浏览器名称
 */
export const getExplorer = () => {
    const ua = window.navigator.userAgent
    const isExplorer = (exp) => {
        return ua.indexOf(exp) > -1
    }
    if (isExplorer('MSIE')) return 'IE'
    else if (isExplorer('Firefox')) return 'Firefox'
    else if (isExplorer('Chrome')) return 'Chrome'
    else if (isExplorer('Opera')) return 'Opera'
    else if (isExplorer('Safari')) return 'Safari'
}

/**
 * @description 绑定事件 on(element, event, handler)
 */
export const on = (function () {
    if (document.addEventListener) {
        return function (element, event, handler) {
            if (element && event && handler) {
                element.addEventListener(event, handler, false)
            }
        }
    } else {
        return function (element, event, handler) {
            if (element && event && handler) {
                element.attachEvent('on' + event, handler)
            }
        }
    }
})()

/**
 * @description 解绑事件 off(element, event, handler)
 */
export const off = (function () {
    if (document.removeEventListener) {
        return function (element, event, handler) {
            if (element && event) {
                element.removeEventListener(event, handler, false)
            }
        }
    } else {
        return function (element, event, handler) {
            if (element && event) {
                element.detachEvent('on' + event, handler)
            }
        }
    }
})()

/**
 * 判断一个对象是否存在key，如果传入第二个参数key，则是判断这个obj对象是否存在key这个属性
 * 如果没有传入key这个参数，则判断obj对象是否有键值对
 */
export const hasKey = (obj, key) => {
    if (key) return key in obj
    else {
        let keysArr = Object.keys(obj)
        return keysArr.length
    }
}

/**
 * @param {*} obj1 对象
 * @param {*} obj2 对象
 * @description 判断两个对象是否相等，这两个对象的值只能是数字或字符串
 */
export const objEqual = (obj1, obj2) => {
    const keysArr1 = Object.keys(obj1)
    const keysArr2 = Object.keys(obj2)
    if (keysArr1.length !== keysArr2.length) return false
    else if (keysArr1.length === 0 && keysArr2.length === 0) return true
    /* eslint-disable-next-line */ else return !keysArr1.some((key) => obj1[key] != obj2[key])
}

const showOrHideClass = (className, isShow) => {
    const classADivs = document.querySelectorAll('.' + className)
    classADivs.forEach((div) => {
        div.style.display = isShow ? 'inline-block' : 'none !important'
    })
}

/**
 * 获取行内按钮权限
 * @param {*} url
 */
export const getRowButtonPower = (url) => {
    const childSysMenuPower = JSON.parse(sessionStorage.getItem('childSysMenuPower'))
    const listPower = Utility.arrayFlat(childSysMenuPower, (t) => t.children)
    const item = listPower?.find((t) => t.menu_url == url)
    // 查询|添加|修改|删除|指令下发|审核|下载
    const button_per = item?.button_per?.split('|')
    setTimeout(() => {
        showOrHideClass('type0', button_per?.[0] === 1)
        showOrHideClass('type1', button_per?.[1] === 1)
        showOrHideClass('type2', button_per?.[2] === 1)
        showOrHideClass('type3', button_per?.[3] === 1)
        showOrHideClass('type4', button_per?.[4] === 1)
        showOrHideClass('type5', button_per?.[5] === 1)
        showOrHideClass('type6', button_per?.[6] === 1)
    }, 1000)
}

/** 获取右上角按钮权限 */
export const getButtonPower = (url, type) => {
    try {
        // 定义按钮类型
        // 查询按钮
        const searchType = ['search', 'reset', 'custom', 'zk', 'ss', 'view', 'lookSMJ']
        // 新增按钮
        const addType = ['add', 'createUser', 'moreUser']
        // 编辑按钮
        const editType = [
            'pledit',
            'edit',
            'mergeUser',
            'editUser',
            'moneyChangeUser',
            'initUser',
            'userZero',
            'resetPwd',
            'relationMenu',
            'relationUser'
        ]
        // 删除
        const deleteType = ['userRemove', 'plxh', 'delete']
        // 指令下发
        const orderType = ['plOpr', 'systemParams', 'userParams', 'tdd', 'xiafa']
        // 审核
        const checkType = ['save']
        // 下载
        const downloadType = ['print', 'import', 'download']

        const childSysMenuPower = JSON.parse(sessionStorage.getItem('childSysMenuPower'))
        const listPower = Utility.arrayFlat(childSysMenuPower, (t) => t.children)
        const item = listPower?.find((t) => t.menu_url == url)
        // 查询|添加|修改|删除|指令下发|审核|下载
        const button_per = item?.button_per?.split('|')
        if (searchType.includes(type)) {
            return button_per?.[0] == 1
        }
        if (addType.includes(type)) {
            return button_per?.[1] == 1
        }
        if (editType.includes(type)) {
            return button_per?.[2] == 1
        }
        if (deleteType.includes(type)) {
            return button_per?.[3] == 1
        }
        if (orderType.includes(type)) {
            return button_per?.[4] == 1
        }
        if (checkType.includes(type)) {
            return button_per?.[5] == 1
        }
        if (downloadType.includes(type)) {
            return button_per?.[6] == 1
        }
    } catch (error) {
        return false
    }
}

/**
 * 数字小写转中文金额大写（.00转为元整）
 * @param {number|string} num - 需要转换的金额数字
 * @returns {string} 中文大写金额
 */
export function moneyToChinese(num) {
    // 处理空值或非数字
    if (!num || isNaN(Number(num))) return '零元整'

    // 中文数字映射
    const digitMap = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖']
    // 单位映射（个、十、百、千、万、亿）
    const unitMap = ['', '拾', '佰', '仟', '万', '拾', '佰', '仟', '亿', '拾', '佰', '仟']
    // 金额单位
    const moneyUnit = ['元', '角', '分']

    // 将数字转为字符串并分割整数和小数部分，小数部分补零到两位
    const [integerPart, decimalPart = ''] = String(num).split('.')
    const fixedDecimal = (decimalPart + '00').slice(0, 2) // 确保小数部分两位，不足补零

    // 处理整数部分为数组（逆序，方便按位处理）
    const integerDigits = integerPart.split('').reverse()
    let chineseResult = ''

    // 处理整数部分
    for (let i = 0; i < integerDigits.length; i++) {
        const digit = parseInt(integerDigits[i])
        const unit = unitMap[i] // 当前位的单位

        // 跳过连续的零，但保留单位（万、亿）
        if (digit === 0) {
            // 非末尾的零，且下一位非零，才添加“零”
            if (i < integerDigits.length - 1 && parseInt(integerDigits[i + 1]) !== 0) {
                chineseResult = digitMap[digit] + chineseResult
            }
            // 保留万、亿单位（避免“零万”）
            if (unit === '万' || unit === '亿') {
                chineseResult = unit + chineseResult
            }
        } else {
            // 非零数字，拼接数字+单位
            chineseResult = digitMap[digit] + unit + chineseResult
        }
    }

    // 处理整数部分开头的“零”（如输入00123），若无整数部分则为“零”
    chineseResult = chineseResult.replace(/^零+/, '') || '零'

    // 拼接“元”
    chineseResult += moneyUnit[0]

    // 处理小数部分：.00 转为“整”，否则拼接角分
    if (fixedDecimal === '00') {
        chineseResult += '整'
    } else {
        const jiaoDigit = parseInt(fixedDecimal[0])
        const fenDigit = parseInt(fixedDecimal[1])

        // 处理角
        if (jiaoDigit !== 0) {
            chineseResult += digitMap[jiaoDigit] + moneyUnit[1]
        } else if (fenDigit !== 0) {
            // 角为零但分为非零，需补“零”
            chineseResult += '零'
        }

        // 处理分
        if (fenDigit !== 0) {
            chineseResult += digitMap[fenDigit] + moneyUnit[2]
        }
    }

    // 特殊处理：拾开头（如10→拾元整，12→拾贰元整）
    chineseResult = chineseResult.replace(/^壹拾/, '拾')

    return chineseResult
}

/**
 * 打印
 * @param {*} domId
 */
export async function printAsPDF(domId, title) {
    const printArea = document.getElementById(domId)

    // 1. 使用 html2canvas 将目标区域转为 Canvas
    html2canvas(printArea, {
        scale: 2, // 提高分辨率（避免打印模糊）
        useCORS: true, // 允许跨域图片
        logging: false // 关闭日志
    }).then((canvas) => {
        // 2. 将 Canvas 转为图片 URL（Base64）
        const imgUrl = canvas.toDataURL('image/png')
        // 3. 方式1：使用 print.js 打印图片
        printJS({
            printable: imgUrl,
            type: 'image',
            documentTitle: title,
            style: `
        @media print {
          body { text-align: center; }
          img { max-width: 100%; }
        }
      `
        })
    })
}
